home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / program / misc / fpl-v13.lha / fpl / src / caller.c next >
C/C++ Source or Header  |  1995-08-22  |  14KB  |  470 lines
  1. /******************************************************************************
  2.  *                   FREXX PROGRAMMING LANGUAGE                  *
  3.  ******************************************************************************
  4.  
  5.  caller.c
  6.  
  7.  For FPL debugging...
  8.  Only part of the executable file version of FPL.
  9.  
  10.  *****************************************************************************/
  11.  
  12. /************************************************************************
  13.  *                                                                      *
  14.  * fpl.library - A shared library interpreting script langauge.         *
  15.  * Copyright (C) 1992-1995 FrexxWare                                    *
  16.  * Author: Daniel Stenberg                                              *
  17.  *                                                                      *
  18.  * This program is free software; you may redistribute for non          *
  19.  * commercial purposes only. Commercial programs must have a written    *
  20.  * permission from the author to use FPL. FPL is *NOT* public domain!   *
  21.  * Any provided source code is only for reference and for assurance     *
  22.  * that users should be able to compile FPL on any operating system     *
  23.  * he/she wants to use it in!                                           *
  24.  *                                                                      *
  25.  * You may not change, resource, patch files or in any way reverse      *
  26.  * engineer anything in the FPL package.                                *
  27.  *                                                                      *
  28.  * This program is distributed in the hope that it will be useful,      *
  29.  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
  30.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                 *
  31.  *                                                                      *
  32.  * Daniel Stenberg                                                      *
  33.  * Ankdammsgatan 36, 4tr                                                *
  34.  * S-171 43 Solna                                                       *
  35.  * Sweden                                                               *
  36.  *                                                                      *
  37.  * FidoNet 2:201/328    email:dast@sth.frontec.se                       *
  38.  *                                                                      *
  39.  ************************************************************************/
  40.  
  41.  
  42. #include "FPL.h"
  43. #include "reference.h"        /* should be <FPL/reference.h> */
  44.  
  45. #ifdef AMIGA
  46. #include <exec/types.h>
  47. #include <proto/exec.h>
  48.  
  49. int CXBRK(void) { return(0); }  /* Disable Lattice/SAS CTRL/C handling */
  50. int chkabort(void) { return(0); }  /* really */
  51. #ifdef SHARED
  52. #include <exec/libraries.h>
  53. #include <libraries/dos.h>
  54.  
  55. #include "/include/pragmas/FPL_pragmas.h"
  56. #include "/include/clib/FPL_protos.h"
  57. struct Library *FPLBase = NULL;
  58. #endif
  59.  
  60. #define REG(x) register __ ## x
  61.  
  62. #elif defined(UNIX) /* #ifdef AMIGA */
  63. #include <sys/types.h>
  64.  
  65. #if defined(__GCC_NEW_VARARGS__) /* && defined(__GCC__) */
  66. /*
  67.  * If you want this file to be compiled using the va_* macros instead of the
  68.  * dirty "address of parameter version", define as below!
  69.  * (Without this define, SunOS 4.1.x versions will likely crash!)
  70.  */
  71.  
  72. #define VARARG_FUNCTIONS /* should be defined before the includes below */
  73. #endif
  74.  
  75.  
  76. #define REG(x)
  77. #define TRUE  1
  78. #define FALSE 0
  79. #include "../include/clib/FPL_protos.h"
  80.  
  81. #endif
  82.  
  83. #include <stdlib.h>
  84. #include <string.h>
  85. #include <stdio.h>
  86. #include <stdarg.h>
  87.  
  88. #if defined(AMIGA) && defined(SHARED)
  89. #define CALLER __saveds
  90. #define ASM __asm
  91. #else
  92. #define CALLER
  93. #define ASM
  94. #endif
  95.  
  96. long ASM func(REG(a0) struct fplArgument *);
  97. long ASM inter(REG(a0) void *);
  98. void CALLER ASM MyFree(REG(a1) void *, REG(d0) long);
  99. void CALLER ASM *MyAlloc(REG(d0) long);
  100. long ASM newline(REG(a0) void *);
  101.  
  102. int memory_counter=0;
  103. int maxmemory_counter=0;
  104. int mallocs=0;
  105.  
  106. int newlines=0;
  107.  
  108. enum myfunctions {
  109.   FN_GETINT,
  110.   FN_GETSTRING,
  111.   FN_OUTPUT,
  112.   FN_EXECUTE,
  113.   FN_PRINTF,
  114.   FN_TEST,
  115.   FN_OPENL,
  116.   FN_CLOSEL,
  117.  
  118.   VR_TEST /* first variable ever! */
  119.  
  120.   };
  121.  
  122.  
  123.  
  124. /**********************************************************************
  125.  *
  126.  * int main(int, char **)
  127.  *
  128.  * This function is not included in the run time library version.
  129.  *
  130.  ******/
  131.  
  132. void *key;
  133.  
  134. int main(int argc, char **argv)
  135. {
  136.   long n, end=0;
  137.   long count=0;
  138.   int pre_mallocs;
  139.   long pre_malloc;
  140.   struct fplSymbol *symbols;
  141.   long i;
  142.   long Version_I,Revision_I;
  143.  
  144. #if defined(SHARED) && defined(AMIGA)
  145.   if(!(FPLBase=OpenLibrary(FPLNAME, 5))) {
  146.     printf("Error opening %s!\n", FPLNAME);
  147.     return(-1);
  148.   }
  149. #endif
  150.  
  151.   if(argc<2) {
  152.     printf("Usage: SFPL <FPL program file name>\n");
  153. #if defined(AMIGA) && defined(SHARED)
  154.     CloseLibrary((struct Library *)FPLBase);
  155. #endif
  156.     return 0;
  157.   }
  158.  
  159.   key=fplInitTags(func,
  160.           FPLTAG_INTERVAL, (unsigned long)inter, /* interval func */
  161.           FPLTAG_USERDATA, (unsigned long)&count, /* user data */
  162.           FPLTAG_INTERNAL_DEALLOC, (unsigned long)MyFree,
  163.           FPLTAG_INTERNAL_ALLOC, (unsigned long)MyAlloc,
  164.           FPLTAG_MINSTACK, 7000,
  165.           FPLTAG_CACHEALLFILES, FPLCACHE_EXPORTS,
  166.                   FPLTAG_REREAD_CHANGES, TRUE,
  167.                   FPLTAG_IDENTITY, argv[0], /* identify us! */
  168.           FPLTAG_DEBUG, TRUE,  /* run in debug mode! */
  169.           FPLTAG_DONE);
  170.  
  171.   fplSendTags( key, FPLSEND_GETVERSION, &Version_I,
  172.                     FPLSEND_GETREVISION, &Revision_I, FPLSEND_DONE);
  173.   printf("Using FPL version %d.%d.\n",Version_I,Revision_I);
  174.   
  175.   fplAddFunction(key, "getint",    FN_GETINT,    'I', "s", NULL);
  176.   fplAddFunction(key, "getstring", FN_GETSTRING, 'S', "s", NULL);
  177.   fplAddFunction(key, "output",       FN_OUTPUT,    'S', "O", NULL);
  178.   fplAddFunction(key, "runfile",   FN_EXECUTE,   'I', "S", NULL);
  179.   fplAddFunction(key, "printf",    FN_PRINTF,    'I', "So>", NULL);
  180.   fplAddFunction(key, "array",     FN_TEST,      'I', "R", NULL);  
  181.  
  182.   fplAddVariable(key, "_TEST_",    VR_TEST,      'S', NULL, NULL);
  183.  
  184.   pre_mallocs=mallocs;
  185.   pre_malloc=memory_counter;
  186.  
  187. #if 1
  188.   if(!end && argc>1) {
  189.     int i;
  190.     for(i=1; i<argc; i++) {
  191.       char *string=NULL;
  192.       end=fplExecuteFileTags(key, argv[i],
  193.                              FPLTAG_ISOLATE, TRUE,
  194.                              FPLTAG_STRING_RETURN, &string,
  195.                              FPLTAG_DONE);
  196.       if(string) {
  197.         printf("The '%s' program returned '%s'\n", argv[i], string);
  198.         fplFreeString(key, string);
  199.       }
  200.     }
  201.   }
  202. #else
  203.   {
  204.     char *program1 =
  205.       "string lastsearch;\n export void tut(void) {string test; test = lastsearch;} }";
  206.     fplExecuteScriptTags(key, &program1, 1,
  207.                          FPLTAG_KIDNAP_CACHED, TRUE,
  208.                          FPLTAG_CACHEFILE, FPLCACHE_EXPORTS,
  209.                          FPLTAG_PROGNAME, "program1",
  210.                          FPLTAG_DONE);
  211.     program1 = "tut(); ";
  212.     fplExecuteScriptTags(key, &program1, 1,
  213.                          FPLTAG_DONE);
  214.   }
  215. #endif
  216.  
  217. #if 0  
  218.   fplSendTags(key, FPLSEND_GETSYMBOL_FUNCTIONS, &symbols, FPLSEND_DONE);
  219.   printf("\n---------------------\nAll exported functions:\n");
  220.   for(i=0; i<symbols->num; i++)
  221.     printf("%s ", symbols->array[i]);
  222.   fplSendTags(key, FPLSEND_GETSYMBOL_FREE, symbols, FPLSEND_DONE);
  223.  
  224.   fplSendTags(key, FPLSEND_GETSYMBOL_VARIABLES, &symbols, FPLSEND_DONE);
  225.   printf("\n---------------------\nAll exported variables:\n");
  226.   for(i=0; i<symbols->num; i++)
  227.     printf("%s ", symbols->array[i]);
  228.   fplSendTags(key, FPLSEND_GETSYMBOL_FREE, symbols, FPLSEND_DONE);
  229.  
  230.   fplSendTags(key, FPLSEND_GETSYMBOL_CACHEDFILES, &symbols, FPLSEND_DONE);
  231.   printf("\n---------------------\nAll cached files:\n");
  232.   for(i=0; i<symbols->num; i++)
  233.     printf("%s ", symbols->array[i]);
  234.   fplSendTags(key, FPLSEND_GETSYMBOL_FREE, symbols, FPLSEND_DONE);
  235. #endif
  236.  
  237.   fplSendTags(key,
  238.           FPLSEND_GETRETURNCODE, &n,
  239.           FPLSEND_FLUSHFILE, 0,
  240.           FPLSEND_FLUSHCACHE, 1,
  241.           FPLSEND_DONE);
  242.  
  243.   fplFree(key); /* free all shit FPL uses internally */
  244.  
  245. #if defined(AMIGA) && defined(SHARED)
  246.   CloseLibrary((struct Library *)FPLBase);
  247. #endif
  248.  
  249. #ifdef DEBUG_INFO  
  250.   printf("\n-----------------------------------------\n");
  251.   printf("Return code   :  %d\n", n);
  252.   printf("Interval func :  %d\n", count);
  253.   printf("Newlines      :  %d\n", newlines);
  254.   printf("Pre mallocs   :  %d\n", pre_mallocs);
  255.   printf("Pre memory use:  %d\n", pre_malloc);
  256.   printf("Malloc        :  %d\n", mallocs-pre_mallocs);
  257.   printf("memory use    :  %d\n", maxmemory_counter-pre_malloc);
  258.   printf("-----------------------------------------\n");
  259. #endif
  260.  
  261.   if(memory_counter)
  262.     printf(">ALARM!!< Not freed mem :  %d bytes!\n", memory_counter);
  263.  
  264.   return end;
  265. }
  266.  
  267.  
  268.  
  269. #define TEST_STRING "I_returned_this_from_the_interface_function!"
  270.  
  271. long ASM func(REG(a0) struct fplArgument *arg)
  272. {
  273.   int ret;
  274.   long col;
  275.   char *name;
  276.   char *string;
  277.   void *anchor=arg->key;
  278.   char systemline[80];
  279.   switch(arg->ID) {
  280.   case VR_TEST:
  281.     fplSendTags(anchor, FPLSEND_STRING, "internal variable!", FPLSEND_DONE);
  282.     break;
  283.   case FN_TEST:
  284.     {
  285.       long new[2]={0,-1};
  286.       long *integer;
  287.       fplReferenceTags(anchor, arg->argv[0],
  288.                        FPLREF_NAME, &name,
  289.                FPLREF_TYPE, &col,
  290.                FPLREF_GET_STRING, &string,
  291.                FPLREF_GET_INTEGER, &integer,
  292.                FPLREF_DONE);
  293.       printf("Received a reference to the %s %svariable called '%s'\n",
  294.              col&FPLREF_TYPE_STRING?"string":"integer",
  295.              col&FPLREF_TYPE_ARRAY?"array ":"",
  296.              name);
  297.  
  298.       if(col&FPLREF_TYPE_ARRAY) {
  299.     struct fplRef ref;
  300.     fplReferenceTags(anchor, arg->argv[0],
  301.              FPLREF_ARRAY_INFO, &ref,
  302.              FPLREF_DONE);
  303.     if(1 == ref.Dimensions) {
  304.       long dims[]={0, -1};
  305.       for(col=0; col<ref.ArraySize[0]; col++) {
  306.         dims[0]=col;
  307.         fplReferenceTags(anchor, arg->argv[0],
  308.                  FPLREF_ARRAY_ITEM, &dims[0],
  309.                  FPLREF_GET_STRING, &name,
  310.                  FPLREF_DONE);
  311.         if(name[0])
  312.           printf("#%d: %s\n", col, name);
  313.       }
  314.       new[0] = 5;
  315.       fplReferenceTags(anchor, arg->argv[0],
  316.                FPLREF_ARRAY_ITEM, &dims[0],
  317.                FPLREF_SET_MY_STRING, "externally set",
  318.                FPLREF_DONE);
  319.           ref.ArraySize = new;
  320.           new[0] = 20;
  321.       fplReferenceTags(anchor, arg->argv[0],
  322.                            FPLREF_ARRAY_RESIZE, &ref,
  323.                FPLREF_DONE);
  324.     }
  325.       }
  326.       else if(col&FPLREF_TYPE_STRING) {
  327.         printf("It holds the string '%s'\n", string);
  328.     if(string=(char *)fplAllocString(anchor, strlen(TEST_STRING))) {
  329.           strcpy(string, TEST_STRING);
  330.       fplReferenceTags(anchor, arg->argv[0],
  331.                        FPLREF_SET_STRING, string,
  332.                    FPLREF_END);
  333.       fplReferenceTags(anchor, arg->argv[0],
  334.                        FPLREF_SET_MY_STRING, TEST_STRING,
  335.                    FPLREF_END);
  336.     }
  337.       } else if(col&FPLREF_TYPE_INTEGER) {
  338.         printf("It holds the number %d\n", *integer);      
  339.       }
  340.     }
  341.     break;
  342.  
  343.   case FN_PRINTF:
  344. #if defined(AMIGA)
  345.     vprintf(arg->argv[0], (char *)&arg->argv[1]);
  346. #elif defined(UNIX)
  347.     vfprintf(stderr, arg->argv[0], (char *)&arg->argv[1]);
  348. #endif
  349.     break;
  350.   case FN_OUTPUT: /* output */
  351.     if(arg->format[0]==FPL_STRARG)  /* we got a string! */
  352.       string="%s";
  353.     else
  354.       string="%d";
  355. #if defined(AMIGA)
  356.     printf(string, arg->argv[0]);
  357. #elif defined(UNIX)
  358.     fprintf(stderr, string, arg->argv[0]);
  359. #endif
  360. /*
  361.     if(arg->format[0]==FPL_STRARG)
  362.         fplSendTags(anchor, FPLSEND_INT, 1, FPLSEND_DONE);
  363.     else
  364.         fplSendTags(arg->key,
  365.                     FPLSEND_STRING, "returned",
  366.                     FPLSEND_DONE);
  367. */
  368.     break;
  369.     
  370.   case FN_GETSTRING:
  371.     if(string=(char *)fplAlloc(anchor, 64)) {
  372.       if(arg->argc)
  373.     printf("%s", arg->argv[0]);
  374.       fgets(string, 64, stdin);
  375.       ret=fplSendTags(arg->key,
  376.               FPLSEND_STRING, string,
  377.               FPLSEND_STRLEN, strlen(string)-1,
  378.               FPLSEND_DONE);
  379.       fplDealloc(anchor, string);
  380.     } else
  381.       ret=FPLERR_OUT_OF_MEMORY;
  382.     return(ret);
  383.  
  384.   case FN_EXECUTE:
  385.     ret=fplExecuteFile(anchor, arg->argv[0], NULL);
  386.     return(ret);
  387.     break;
  388.  
  389.   case FPL_GENERAL_ERROR:
  390.     {
  391.       char buffer[FPL_ERRORMSG_LENGTH];
  392.       fplSendTags(anchor,
  393.           FPLSEND_GETVIRLINE, &col,
  394.           FPLSEND_GETVIRFILE, &name,
  395.           FPLSEND_DONE);
  396.       if(*name=='\"') {
  397.     ret=0;
  398.     name++;
  399.     while(name[ret] && name[ret]!='\"')
  400.       ret++;
  401.     string=(char *)fplAlloca(anchor, ret+1);
  402.     memcpy(string, name, ret);
  403.     string[ret]='\0';
  404.       } else {
  405.     string=name;
  406.     ret=0;
  407.       }
  408.       printf("\n>>> %s\n",
  409.          fplGetErrorMsg(arg->key, (long)arg->argv[0], buffer));
  410.       printf(">>> Line %d in file \"%s\". <<<\n", col, string);
  411.       if(ret)
  412.     fplDealloca(anchor, string);
  413.     }
  414.     break;
  415.  
  416.   case FPL_UNKNOWN_FUNCTION:
  417.     col=22; /* only to breakpoint */
  418.     break;
  419.  
  420.   case FN_GETINT:
  421.     if(arg->argc)
  422.       printf("%s", (char *)arg->argv[0]);
  423.     scanf("%d", &ret);
  424.     ret=fplSendTags(anchor, FPLSEND_INT, ret, FPLSEND_DONE);
  425.     return(ret);
  426.   }
  427.   return FPL_OK;
  428. }
  429.  
  430. long ASM inter(REG(a0) void *count)
  431. {
  432.   static line=-1;
  433. #if 0
  434.   static char *name;
  435.   long current_line;
  436.   char *curr_name;
  437.  
  438.   fplSendTags(key, FPLSEND_GETVIRLINE, ¤t_line, FPLSEND_DONE);
  439.   fplSendTags(key, FPLSEND_GETVIRFILE, &curr_name, FPLSEND_DONE);
  440.   if(line!=current_line || name != curr_name) {
  441.     line=current_line;
  442.     name=curr_name;
  443. /*    fprintf(stderr, " < %d %s > ", line, name?name:"unknwon"); */
  444.   }
  445. #endif
  446.  
  447.   (*(int *)count)++; /* just to count the number of times this routine has been
  448.             called. */
  449.   return(0);
  450. }
  451.  
  452. void CALLER ASM MyFree(REG(a1) void *pntr, REG(d0) long size)
  453. {
  454.   memory_counter-=size;
  455.   memset(pntr, 0xaa, size); /* mess up this area before free! */
  456.   free(pntr);
  457. }
  458.  
  459. void CALLER ASM *MyAlloc(REG(d0) long size)
  460. {
  461.   void *mem;
  462.   mallocs++;
  463.   if((memory_counter+=size)>maxmemory_counter)
  464.     maxmemory_counter=memory_counter;
  465.   mem=malloc(size);
  466.   if(mem)
  467.     memset(mem, 0xaa, size); /* mess up this area before free! */
  468.   return (mem);
  469. }
  470.